const jwt = require('jsonwebtoken');
const mongoose = require('mongoose');
const User = require('../models/User');
const Joi = require('joi');

// JWT密钥
const JWT_SECRET = process.env.JWT_SECRET || 'your_jwt_secret_key';

// 注册验证Schema
const registerSchema = Joi.object({
  username: Joi.string().min(3).max(20).required(),
  name: Joi.string().max(50).required(),
  email: Joi.string().email().required(),
  password: Joi.string().min(6).required(),
  skills: Joi.array().items(Joi.string())
});

// 登录验证Schema
const loginSchema = Joi.object({
  username: Joi.string().required(),
  password: Joi.string().required()
});

// 用户注册
exports.register = async (req, res) => {
  try {
    // 验证输入
    const { error, value } = registerSchema.validate(req.body);
    if (error) {
      return res.status(400).json({
        success: false,
        message: '输入验证失败',
        error: error.details[0].message
      });
    }

    const { username, name, email, password, skills } = value;

    // 检查用户是否已存在
    const existingUser = await User.findOne({
      $or: [{ username }, { email }]
    });

    if (existingUser) {
      return res.status(400).json({
        success: false,
        message: '用户名或邮箱已存在'
      });
    }

    // 创建新用户
    const user = new User({
      username,
      name,
      email,
      password,
      skills: skills || []
    });

    await user.save();

    // 生成JWT令牌
    const token = jwt.sign(
      { userId: user._id, role: user.role },
      JWT_SECRET,
      { expiresIn: '7d' }
    );

    res.status(201).json({
      success: true,
      message: '用户注册成功',
      data: {
        user: user.toJSON(),
        token
      }
    });
  } catch (error) {
    console.error('注册错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器内部错误',
      error: process.env.NODE_ENV === 'development' ? error.message : {}
    });
  }
};

// 处理模拟登录的辅助函数
function handleMockLogin(username, password, res) {
  // 预设的测试账户
  const testAccounts = {
    'admin': {
      password: 'admin123',
      role: 'admin',
      name: '系统管理员',
      email: 'admin@activity-system.com'
    },
    'testuser': {
      password: 'test123',
      role: 'user',
      name: '测试用户',
      email: 'test@example.com'
    },
    'demo': {
      password: 'demo123',
      role: 'user',
      name: '演示用户',
      email: 'demo@example.com'
    }
  };

  // 检查是否为预设测试账户
  const testAccount = testAccounts[username];
  
  let mockUser;
  if (testAccount && password === testAccount.password) {
    mockUser = {
      _id: `${testAccount.role}-${username}-${Date.now()}`,
      username,
      name: testAccount.name,
      email: testAccount.email,
      role: testAccount.role,
      status: 'online',
      avatar: testAccount.role === 'admin' ? '/admin-avatar.png' : '/user-avatar.png',
      skills: testAccount.role === 'admin' ? ['管理', '配置', '分析'] : ['基础操作'],
      toJSON: function() { return { ...this }; }
    };
  } else {
    // 通用模拟用户（任意用户名和密码都可登录）
    mockUser = {
      _id: `user-${username || 'guest'}-${Date.now()}`,
      username: username || 'guest',
      name: `模拟用户${username || 'guest'}`,
      email: `${username || 'guest'}@example.com`,
      role: 'user',
      status: 'online',
      avatar: '/user-avatar.png',
      skills: ['基础操作'],
      toJSON: function() { return { ...this }; }
    };
  }
  
  return sendLoginSuccessResponse(mockUser, res, true);
}

// 发送登录成功响应的辅助函数
function sendLoginSuccessResponse(user, res, isMock = false) {
  // 生成JWT令牌
  const token = jwt.sign(
    { userId: user._id, role: user.role },
    JWT_SECRET,
    { expiresIn: '7d' }
  );

  return res.status(200).json({
    success: true,
    message: isMock ? '登录成功（模拟数据模式）' : '登录成功',
    isMock,
    data: {
      user: user.toJSON(),
      token,
      expiresIn: '7d'
    },
    timestamp: new Date().toISOString()
  });
}

// 用户登录
exports.login = async (req, res) => {
  try {
    // 验证输入
    const { error, value } = loginSchema.validate(req.body);
    if (error) {
      return res.status(400).json({
        success: false,
        message: '输入验证失败',
        error: error.details[0].message,
        timestamp: new Date().toISOString()
      });
    }

    const { username, password } = value;

    // 检查数据库连接状态
    const isDbConnected = mongoose.connection.readyState === 1;
    
    if (!isDbConnected) {
      console.log('[模拟模式] 数据库未连接，提供模拟登录响应');
      return handleMockLogin(username, password, res);
    }

    try {
      // 正常登录逻辑 - 包装在try-catch中以捕获可能的数据库错误
      // 查找用户
      const user = await User.findOne({
        $or: [{ username }, { email: username }]
      });

      if (!user) {
        return res.status(401).json({
          success: false,
          message: '用户名或密码错误',
          timestamp: new Date().toISOString()
        });
      }

      // 验证密码
      const isPasswordValid = await user.comparePassword(password);
      if (!isPasswordValid) {
        return res.status(401).json({
          success: false,
          message: '用户名或密码错误',
          timestamp: new Date().toISOString()
        });
      }

      // 更新用户状态为在线
      user.status = 'online';
      await user.save();

      // 返回成功响应
      return sendLoginSuccessResponse(user, res, false);
    } catch (dbError) {
      // 捕获数据库操作过程中的错误
      console.error('数据库操作错误:', dbError);
      console.log('[降级模式] 数据库操作失败，提供模拟登录响应');
      return handleMockLogin(username, password, res);
    }
  } catch (error) {
    // 检查是否为数据库连接相关错误
    if (error.name === 'MongoNetworkError' || 
        error.message.includes('ECONNREFUSED') || 
        error.message.includes('connect') ||
        error.message.includes('MongoError')) {
      console.log('[紧急模式] 数据库连接错误，提供模拟登录响应');
      const { username, password } = req.body || {};
      return handleMockLogin(username, password, res);
    }
    
    console.error('登录错误:', error);
    return res.status(500).json({
      success: false,
      message: '登录失败，请稍后重试',
      error: process.env.NODE_ENV === 'development' ? error.message : undefined,
      timestamp: new Date().toISOString()
    });
  }
};

// 用户登出
exports.logout = async (req, res) => {
  try {
    // 从请求中获取用户ID（通过认证中间件）
    const userId = req.user.userId;

    // 更新用户状态为离线
    await User.findByIdAndUpdate(userId, { status: 'offline' });

    res.status(200).json({
      success: true,
      message: '登出成功'
    });
  } catch (error) {
    console.error('登出错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器内部错误',
      error: process.env.NODE_ENV === 'development' ? error.message : {}
    });
  }
};

// 获取当前用户信息
exports.getCurrentUser = async (req, res) => {
  try {
    const user = await User.findById(req.user.userId);
    
    if (!user) {
      return res.status(404).json({
        success: false,
        message: '用户不存在'
      });
    }

    res.status(200).json({
      success: true,
      data: {
        user: user.toJSON()
      }
    });
  } catch (error) {
    console.error('获取用户信息错误:', error);
    res.status(500).json({
      success: false,
      message: '服务器内部错误',
      error: process.env.NODE_ENV === 'development' ? error.message : {}
    });
  }
};